package cn.ywyu.classfinal.util;

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 字符串工具
 */
public class StrUtils {
    /**
     * 逗号分割的字符串转list
     *
     * @param str 逗号分割的字串
     * @return list
     */
    public static List<String> toList(String str) {
        return Optional.ofNullable(str)
                .map(s -> Arrays.stream(s.split(",")))
                .orElse(Stream.empty())
                .map(String::trim)
                .filter(s -> !s.isEmpty())
                .collect(Collectors.toList());
    }

    /**
     * 判断字符串是否为空
     *
     * @param str 字符串
     * @return 是否是空的
     */
    public static boolean isEmpty(String str) {
        return str == null || str.isEmpty();
    }

    /**
     * 判断字符数组是否为空
     *
     * @param str 字符串
     * @return 是否是空的
     */
    public static boolean isEmpty(char[] str) {
        return str == null || str.length == 0;
    }

    /**
     * 判断字符串是否不为空
     *
     * @param str 字符串
     * @return 是否不是空的
     */
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    /**
     * 判断字符串是否不为空
     *
     * @param str 字符串
     * @return 是否不是空的
     */
    public static boolean isNotEmpty(char[] str) {
        return !isEmpty(str);
    }

    /**
     * 合并byte[]
     *
     * @param bts 字节数组
     * @return 合并后的字节
     */
    public static char[] merger(char[]... bts) {
        int lenght = 0;
        for (char[] b : bts) {
            lenght += b.length;
        }

        char[] bt = new char[lenght];
        int lastLength = 0;
        for (char[] b : bts) {
            System.arraycopy(b, 0, bt, lastLength, b.length);
            lastLength += b.length;
        }
        return bt;
    }

    /**
     * 字节转char数组
     *
     * @param bytes 字节数组
     * @return chars
     */
    public static char[] toChars(byte[] bytes) {
        Charset cs = StandardCharsets.UTF_8;
        ByteBuffer bb = ByteBuffer.allocate(bytes.length);
        bb.put(bytes).flip();
        CharBuffer cb = cs.decode(bb);
        return cb.array();
    }

    /**
     * 字符数组转成字节数组
     *
     * @param chars 字符数组
     * @return 字节数组
     */
    public static byte[] toBytes(char[] chars) {
        char[] chars0 = new char[chars.length];
        System.arraycopy(chars, 0, chars0, 0, chars.length);
        CharBuffer charBuffer = CharBuffer.wrap(chars0);
        ByteBuffer byteBuffer = StandardCharsets.UTF_8.encode(charBuffer);
        byte[] bytes = Arrays.copyOfRange(byteBuffer.array(),
                byteBuffer.position(), byteBuffer.limit());
        Arrays.fill(charBuffer.array(), '\u0000'); // clear sensitive data
        Arrays.fill(byteBuffer.array(), (byte) 0); // clear sensitive data
        return bytes;
    }

    /**
     * 在字符串的某个位置插入字符串
     *
     * @param stringList 字符串数组
     * @param insertStr  要插入的字串
     * @param pos        位置开始标识
     * @return 插入后的字串
     */
    public static String insertStringAtPosition(List<String> stringList, String pos, String insertStr) {
        StringBuilder newStr = new StringBuilder();
        boolean hasInsertionOccurred = false;
        for (String s : stringList) {
            newStr.append(s).append("\r\n");
            if (s.startsWith(pos)) {
                newStr.append(insertStr).append("\r\n");
                hasInsertionOccurred = true;
            }
        }
        if (!hasInsertionOccurred) {
            newStr.append(insertStr).append("\r\n");
        }
        return newStr.toString();
    }

    /**
     * 通配符匹配
     *
     * @param match      匹配字符串
     * @param testString 待匹配字符窜
     * @return 是否匹配
     */
    public static boolean isMatch(String match, String testString) {
        String regex = match.replaceAll("\\?", "(.?)")
                .replaceAll("\\*+", "(.*?)");
        return Pattern.matches(regex, testString);
    }

    /**
     * 判断是否是匹配
     *
     * @param matches    匹配的
     * @param testString 要判断
     * @return 是否属于
     */
    public static boolean isMatches(List<String> matches, String testString) {
        return isMatches(matches, testString, false);
    }

    /**
     * 判断是否是匹配
     *
     * @param matches    匹配的
     * @param testString 要判断
     * @param dv         默认值
     * @return 是否属于
     */
    public static boolean isMatches(List<String> matches, String testString, boolean dv) {
        if (matches == null || matches.isEmpty()) {
            return dv;
        }

        for (String m : matches) {
            if (StrUtils.isMatch(m, testString) || testString.startsWith(m) || testString.endsWith(m)) {
                return true;
            }
        }
        return false;
    }
}
